package svm.libsvm;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Random;
import java.util.StringTokenizer;

//
// Kernel Cache
//
// l is the number of total data items
// size is the cache size limit in bytes
//
class Cache {
   private final int l;
   private long size;
   
   private final class head_t
   {
      head_t prev, next;	// a cicular list
      float[] data;
      int len;		// data[0,len) is cached in this entry
   }
   
   private final head_t[] head;
   private final head_t lru_head;
   
   Cache(final int l_, final long size_)
   {
      l = l_;
      size = size_;
      head = new head_t[l];
      for (int i = 0; i < l; i++) {
         head[i] = new head_t();
      }
      size /= 4;
      size -= l * (16 / 4);	// sizeof(head_t) == 16
      size = Math.max(size, 2 * (long) l);  // cache must be large enough for two columns
      lru_head = new head_t();
      lru_head.next = lru_head.prev = lru_head;
   }
   
   private void lru_delete(final head_t h)
   {
      // delete from current location
      h.prev.next = h.next;
      h.next.prev = h.prev;
   }
   
   private void lru_insert(final head_t h)
   {
      // insert to last position
      h.next = lru_head;
      h.prev = lru_head.prev;
      h.prev.next = h;
      h.next.prev = h;
   }
   
   // request data [0,len)
   // return some position p where [p,len) need to be filled
   // (p >= len if nothing needs to be filled)
   // java: simulate pointer using single-element array
   int get_data(final int index, final float[][] data, int len)
   {
      final head_t h = head[index];
      if (h.len > 0) {
         lru_delete(h);
      }
      final int more = len - h.len;
      
      if (more > 0)
      {
         // free old space
         while (size < more)
         {
            final head_t old = lru_head.next;
            lru_delete(old);
            size += old.len;
            old.data = null;
            old.len = 0;
         }
         
         // allocate new space
         final float[] new_data = new float[len];
         if (h.data != null) {
            System.arraycopy(h.data, 0, new_data, 0, h.len);
         }
         h.data = new_data;
         size -= more;
         do {
            final int _ = h.len;
            h.len = len;
            len = _;
         } while (false);
      }
      
      lru_insert(h);
      data[0] = h.data;
      return len;
   }
   
   void swap_index(int i, int j)
   {
      if (i == j) {
         return;
      }
      
      if (head[i].len > 0) {
         lru_delete(head[i]);
      }
      if (head[j].len > 0) {
         lru_delete(head[j]);
      }
      do {
         final float[] _ = head[i].data;
         head[i].data = head[j].data;
         head[j].data = _;
      } while (false);
      do {
         final int _ = head[i].len;
         head[i].len = head[j].len;
         head[j].len = _;
      } while (false);
      if (head[i].len > 0) {
         lru_insert(head[i]);
      }
      if (head[j].len > 0) {
         lru_insert(head[j]);
      }
      
      if (i > j) {
         do {
            final int _ = i;
            i = j;
            j = _;
         } while (false);
      }
      for (head_t h = lru_head.next; h != lru_head; h = h.next)
      {
         if (h.len > i)
         {
            if (h.len > j) {
               do {
                  final float _ = h.data[i];
                  h.data[i] = h.data[j];
                  h.data[j] = _;
               } while (false);
            }
            else
            {
               // give up
               lru_delete(h);
               size += h.len;
               h.data = null;
               h.len = 0;
            }
         }
      }
   }
}

//
// Kernel evaluation
//
// the static method k_function is for doing single kernel evaluation
// the constructor of Kernel prepares to calculate the l*l kernel matrix
// the member function get_Q is for getting one column from the Q Matrix
//
abstract class QMatrix {
   abstract float[] get_Q(int column, int len);
   
   abstract double[] get_QD();
   
   abstract void swap_index(int i, int j);
};

abstract class Kernel extends QMatrix {
   private final svm_node[][] x;
   private final double[] x_square;
   
   // svm_parameter
   private final int kernel_type;
   private final int degree;
   private final double gamma;
   private final double coef0;
   
   @Override
   abstract float[] get_Q(int column, int len);
   
   @Override
   abstract double[] get_QD();
   
   @Override
   void swap_index(final int i, final int j)
   {
      do {
         final svm_node[] _ = x[i];
         x[i] = x[j];
         x[j] = _;
      } while (false);
      if (x_square != null) {
         do {
            final double _ = x_square[i];
            x_square[i] = x_square[j];
            x_square[j] = _;
         } while (false);
      }
   }
   
   private static double powi(final double base, final int times)
   {
      double tmp = base, ret = 1.0;
      
      for (int t = times; t > 0; t /= 2)
      {
         if (t % 2 == 1) {
            ret *= tmp;
         }
         tmp = tmp * tmp;
      }
      return ret;
   }
   
   double kernel_function(final int i, final int j)
   {
      switch (kernel_type)
      {
         case svm_parameter.LINEAR:
            return dot(x[i], x[j]);
         case svm_parameter.POLY:
            return powi(gamma * dot(x[i], x[j]) + coef0, degree);
         case svm_parameter.RBF:
            return Math.exp(-gamma * (x_square[i] + x_square[j] - 2 * dot(x[i], x[j])));
         case svm_parameter.SIGMOID:
            return Math.tanh(gamma * dot(x[i], x[j]) + coef0);
         case svm_parameter.PRECOMPUTED:
            return x[i][(int) x[j][0].value].value;
         default:
            return 0;	// java
      }
   }
   
   Kernel(final int l, final svm_node[][] x_, final svm_parameter param)
   {
      kernel_type = param.kernel_type;
      degree = param.degree;
      gamma = param.gamma;
      coef0 = param.coef0;
      
      x = x_.clone();
      
      if (kernel_type == svm_parameter.RBF)
      {
         x_square = new double[l];
         for (int i = 0; i < l; i++) {
            x_square[i] = dot(x[i], x[i]);
         }
      }
      else {
         x_square = null;
      }
   }
   
   static double dot(final svm_node[] x, final svm_node[] y)
   {
      double sum = 0;
      final int xlen = x.length;
      final int ylen = y.length;
      int i = 0;
      int j = 0;
      while (i < xlen && j < ylen)
      {
         if (x[i].index == y[j].index) {
            sum += x[i++].value * y[j++].value;
         }
         else
         {
            if (x[i].index > y[j].index) {
               ++j;
            }
            else {
               ++i;
            }
         }
      }
      return sum;
   }
   
   static double k_function(final svm_node[] x, final svm_node[] y,
         final svm_parameter param)
   {
      switch (param.kernel_type)
      {
         case svm_parameter.LINEAR:
            return dot(x, y);
         case svm_parameter.POLY:
            return powi(param.gamma * dot(x, y) + param.coef0, param.degree);
         case svm_parameter.RBF: {
            double sum = 0;
            final int xlen = x.length;
            final int ylen = y.length;
            int i = 0;
            int j = 0;
            while (i < xlen && j < ylen)
            {
               if (x[i].index == y[j].index)
               {
                  final double d = x[i++].value - y[j++].value;
                  sum += d * d;
               }
               else if (x[i].index > y[j].index)
               {
                  sum += y[j].value * y[j].value;
                  ++j;
               }
               else
               {
                  sum += x[i].value * x[i].value;
                  ++i;
               }
            }
            
            while (i < xlen)
            {
               sum += x[i].value * x[i].value;
               ++i;
            }
            
            while (j < ylen)
            {
               sum += y[j].value * y[j].value;
               ++j;
            }
            
            return Math.exp(-param.gamma * sum);
         }
         case svm_parameter.SIGMOID:
            return Math.tanh(param.gamma * dot(x, y) + param.coef0);
         case svm_parameter.PRECOMPUTED:
            return x[(int) y[0].value].value;
         default:
            return 0;	// java
      }
   }
}

// An SMO algorithm in Fan et al., JMLR 6(2005), p. 1889--1918
// Solves:
//
//	min 0.5(\alpha^T Q \alpha) + p^T \alpha
//
//		y^T \alpha = \delta
//		y_i = +1 or -1
//		0 <= alpha_i <= Cp for y_i = 1
//		0 <= alpha_i <= Cn for y_i = -1
//
// Given:
//
//	Q, p, y, Cp, Cn, and an initial feasible point \alpha
//	l is the size of vectors and matrices
//	eps is the stopping tolerance
//
// solution will be put in \alpha, objective value will be put in obj
//
class Solver {
   int active_size;
   byte[] y;
   double[] G;		// gradient of objective function
   static final byte LOWER_BOUND = 0;
   static final byte UPPER_BOUND = 1;
   static final byte FREE = 2;
   byte[] alpha_status;	// LOWER_BOUND, UPPER_BOUND, FREE
   double[] alpha;
   QMatrix Q;
   double[] QD;
   double eps;
   double Cp, Cn;
   double[] p;
   int[] active_set;
   double[] G_bar;		// gradient, if we treat free variables as 0
   int l;
   boolean unshrink;	// XXX
   
   static final double INF = java.lang.Double.POSITIVE_INFINITY;
   
   double get_C(final int i)
   {
      return y[i] > 0 ? Cp : Cn;
   }
   
   void update_alpha_status(final int i)
   {
      if (alpha[i] >= get_C(i)) {
         alpha_status[i] = UPPER_BOUND;
      }
      else if (alpha[i] <= 0) {
         alpha_status[i] = LOWER_BOUND;
      }
      else {
         alpha_status[i] = FREE;
      }
   }
   
   boolean is_upper_bound(final int i) {
      return alpha_status[i] == UPPER_BOUND;
   }
   
   boolean is_lower_bound(final int i) {
      return alpha_status[i] == LOWER_BOUND;
   }
   
   boolean is_free(final int i) {
      return alpha_status[i] == FREE;
   }
   
   // java: information about solution except alpha,
   // because we cannot return multiple values otherwise...
   static class SolutionInfo {
      double obj;
      double rho;
      double upper_bound_p;
      double upper_bound_n;
      double r;	// for Solver_NU
   }
   
   void swap_index(final int i, final int j)
   {
      Q.swap_index(i, j);
      do {
         final byte _ = y[i];
         y[i] = y[j];
         y[j] = _;
      } while (false);
      do {
         final double _ = G[i];
         G[i] = G[j];
         G[j] = _;
      } while (false);
      do {
         final byte _ = alpha_status[i];
         alpha_status[i] = alpha_status[j];
         alpha_status[j] = _;
      } while (false);
      do {
         final double _ = alpha[i];
         alpha[i] = alpha[j];
         alpha[j] = _;
      } while (false);
      do {
         final double _ = p[i];
         p[i] = p[j];
         p[j] = _;
      } while (false);
      do {
         final int _ = active_set[i];
         active_set[i] = active_set[j];
         active_set[j] = _;
      } while (false);
      do {
         final double _ = G_bar[i];
         G_bar[i] = G_bar[j];
         G_bar[j] = _;
      } while (false);
   }
   
   void reconstruct_gradient()
   {
      // reconstruct inactive elements of G from G_bar and free variables
      
      if (active_size == l) {
         return;
      }
      
      int i, j;
      int nr_free = 0;
      
      for (j = active_size; j < l; j++) {
         G[j] = G_bar[j] + p[j];
      }
      
      for (j = 0; j < active_size; j++) {
         if (is_free(j)) {
            nr_free++;
         }
      }
      
      if (2 * nr_free < active_size) {
         svm.info("\nWARNING: using -h 0 may be faster\n");
      }
      
      if (nr_free * l > 2 * active_size * (l - active_size))
      {
         for (i = active_size; i < l; i++)
         {
            final float[] Q_i = Q.get_Q(i, active_size);
            for (j = 0; j < active_size; j++) {
               if (is_free(j)) {
                  G[i] += alpha[j] * Q_i[j];
               }
            }
         }
      }
      else
      {
         for (i = 0; i < active_size; i++) {
            if (is_free(i))
            {
               final float[] Q_i = Q.get_Q(i, l);
               final double alpha_i = alpha[i];
               for (j = active_size; j < l; j++) {
                  G[j] += alpha_i * Q_i[j];
               }
            }
         }
      }
   }
   
   void Solve(final int l, final QMatrix Q, final double[] p_, final byte[] y_,
         final double[] alpha_, final double Cp, final double Cn, final double eps, final SolutionInfo si, final int shrinking)
   {
      this.l = l;
      this.Q = Q;
      QD = Q.get_QD();
      p = p_.clone();
      y = y_.clone();
      alpha = alpha_.clone();
      this.Cp = Cp;
      this.Cn = Cn;
      this.eps = eps;
      unshrink = false;
      
      // initialize alpha_status
      {
         alpha_status = new byte[l];
         for (int i = 0; i < l; i++) {
            update_alpha_status(i);
         }
      }
      
      // initialize active set (for shrinking)
      {
         active_set = new int[l];
         for (int i = 0; i < l; i++) {
            active_set[i] = i;
         }
         active_size = l;
      }
      
      // initialize gradient
      {
         G = new double[l];
         G_bar = new double[l];
         int i;
         for (i = 0; i < l; i++)
         {
            G[i] = p[i];
            G_bar[i] = 0;
         }
         for (i = 0; i < l; i++) {
            if (!is_lower_bound(i))
            {
               final float[] Q_i = Q.get_Q(i, l);
               final double alpha_i = alpha[i];
               int j;
               for (j = 0; j < l; j++) {
                  G[j] += alpha_i * Q_i[j];
               }
               if (is_upper_bound(i)) {
                  for (j = 0; j < l; j++) {
                     G_bar[j] += get_C(i) * Q_i[j];
                  }
               }
            }
         }
      }
      
      // optimization step
      
      int iter = 0;
      final int max_iter = Math.max(10000000, l > Integer.MAX_VALUE / 100 ? Integer.MAX_VALUE : 100 * l);
      int counter = Math.min(l, 1000) + 1;
      final int[] working_set = new int[2];
      
      while (iter < max_iter)
      {
         // show progress and do shrinking
         
         if (--counter == 0)
         {
            counter = Math.min(l, 1000);
            if (shrinking != 0) {
               do_shrinking();
            }
            svm.info(".");
         }
         
         if (select_working_set(working_set) != 0)
         {
            // reconstruct the whole gradient
            reconstruct_gradient();
            // reset active set size and check
            active_size = l;
            svm.info("*");
            if (select_working_set(working_set) != 0) {
               break;
            }
            else {
               counter = 1;	// do shrinking next iteration
            }
         }
         
         final int i = working_set[0];
         final int j = working_set[1];
         
         ++iter;
         
         // update alpha[i] and alpha[j], handle bounds carefully
         
         float[] Q_i = Q.get_Q(i, active_size);
         float[] Q_j = Q.get_Q(j, active_size);
         
         final double C_i = get_C(i);
         final double C_j = get_C(j);
         
         final double old_alpha_i = alpha[i];
         final double old_alpha_j = alpha[j];
         
         if (y[i] != y[j])
         {
            double quad_coef = QD[i] + QD[j] + 2 * Q_i[j];
            if (quad_coef <= 0) {
               quad_coef = 1e-12;
            }
            final double delta = (-G[i] - G[j]) / quad_coef;
            final double diff = alpha[i] - alpha[j];
            alpha[i] += delta;
            alpha[j] += delta;
            
            if (diff > 0)
            {
               if (alpha[j] < 0)
               {
                  alpha[j] = 0;
                  alpha[i] = diff;
               }
            }
            else
            {
               if (alpha[i] < 0)
               {
                  alpha[i] = 0;
                  alpha[j] = -diff;
               }
            }
            if (diff > C_i - C_j)
            {
               if (alpha[i] > C_i)
               {
                  alpha[i] = C_i;
                  alpha[j] = C_i - diff;
               }
            }
            else
            {
               if (alpha[j] > C_j)
               {
                  alpha[j] = C_j;
                  alpha[i] = C_j + diff;
               }
            }
         }
         else
         {
            double quad_coef = QD[i] + QD[j] - 2 * Q_i[j];
            if (quad_coef <= 0) {
               quad_coef = 1e-12;
            }
            final double delta = (G[i] - G[j]) / quad_coef;
            final double sum = alpha[i] + alpha[j];
            alpha[i] -= delta;
            alpha[j] += delta;
            
            if (sum > C_i)
            {
               if (alpha[i] > C_i)
               {
                  alpha[i] = C_i;
                  alpha[j] = sum - C_i;
               }
            }
            else
            {
               if (alpha[j] < 0)
               {
                  alpha[j] = 0;
                  alpha[i] = sum;
               }
            }
            if (sum > C_j)
            {
               if (alpha[j] > C_j)
               {
                  alpha[j] = C_j;
                  alpha[i] = sum - C_j;
               }
            }
            else
            {
               if (alpha[i] < 0)
               {
                  alpha[i] = 0;
                  alpha[j] = sum;
               }
            }
         }
         
         // update G
         
         final double delta_alpha_i = alpha[i] - old_alpha_i;
         final double delta_alpha_j = alpha[j] - old_alpha_j;
         
         for (int k = 0; k < active_size; k++)
         {
            G[k] += Q_i[k] * delta_alpha_i + Q_j[k] * delta_alpha_j;
         }
         
         // update alpha_status and G_bar
         
         {
            final boolean ui = is_upper_bound(i);
            final boolean uj = is_upper_bound(j);
            update_alpha_status(i);
            update_alpha_status(j);
            int k;
            if (ui != is_upper_bound(i))
            {
               Q_i = Q.get_Q(i, l);
               if (ui) {
                  for (k = 0; k < l; k++) {
                     G_bar[k] -= C_i * Q_i[k];
                  }
               }
               else {
                  for (k = 0; k < l; k++) {
                     G_bar[k] += C_i * Q_i[k];
                  }
               }
            }
            
            if (uj != is_upper_bound(j))
            {
               Q_j = Q.get_Q(j, l);
               if (uj) {
                  for (k = 0; k < l; k++) {
                     G_bar[k] -= C_j * Q_j[k];
                  }
               }
               else {
                  for (k = 0; k < l; k++) {
                     G_bar[k] += C_j * Q_j[k];
                  }
               }
            }
         }
         
      }
      
      if (iter >= max_iter)
      {
         if (active_size < l)
         {
            // reconstruct the whole gradient to calculate objective value
            reconstruct_gradient();
            active_size = l;
            svm.info("*");
         }
         svm.info("\nWARNING: reaching max number of iterations");
      }
      
      // calculate rho
      
      si.rho = calculate_rho();
      
      // calculate objective value
      {
         double v = 0;
         int i;
         for (i = 0; i < l; i++) {
            v += alpha[i] * (G[i] + p[i]);
         }
         
         si.obj = v / 2;
      }
      
      // put back the solution
      {
         for (int i = 0; i < l; i++) {
            alpha_[active_set[i]] = alpha[i];
         }
      }
      
      si.upper_bound_p = Cp;
      si.upper_bound_n = Cn;
      
      svm.info("\noptimization finished, #iter = " + iter + "\n");
   }
   
   // return 1 if already optimal, return 0 otherwise
   int select_working_set(final int[] working_set)
   {
      // return i,j such that
      // i: maximizes -y_i * grad(f)_i, i in I_up(\alpha)
      // j: mimimizes the decrease of obj value
      //    (if quadratic coefficeint <= 0, replace it with tau)
      //    -y_j*grad(f)_j < -y_i*grad(f)_i, j in I_low(\alpha)
      
      double Gmax = -INF;
      double Gmax2 = -INF;
      int Gmax_idx = -1;
      int Gmin_idx = -1;
      double obj_diff_min = INF;
      
      for (int t = 0; t < active_size; t++) {
         if (y[t] == +1)
         {
            if (!is_upper_bound(t)) {
               if (-G[t] >= Gmax)
               {
                  Gmax = -G[t];
                  Gmax_idx = t;
               }
            }
         }
         else
         {
            if (!is_lower_bound(t)) {
               if (G[t] >= Gmax)
               {
                  Gmax = G[t];
                  Gmax_idx = t;
               }
            }
         }
      }
      
      final int i = Gmax_idx;
      float[] Q_i = null;
      if (i != -1) {
         Q_i = Q.get_Q(i, active_size);
      }
      
      for (int j = 0; j < active_size; j++)
      {
         if (y[j] == +1)
         {
            if (!is_lower_bound(j))
            {
               final double grad_diff = Gmax + G[j];
               if (G[j] >= Gmax2) {
                  Gmax2 = G[j];
               }
               if (grad_diff > 0)
               {
                  double obj_diff;
                  final double quad_coef = QD[i] + QD[j] - 2.0 * y[i] * Q_i[j];
                  if (quad_coef > 0) {
                     obj_diff = -(grad_diff * grad_diff) / quad_coef;
                  }
                  else {
                     obj_diff = -(grad_diff * grad_diff) / 1e-12;
                  }
                  
                  if (obj_diff <= obj_diff_min)
                  {
                     Gmin_idx = j;
                     obj_diff_min = obj_diff;
                  }
               }
            }
         }
         else
         {
            if (!is_upper_bound(j))
            {
               final double grad_diff = Gmax - G[j];
               if (-G[j] >= Gmax2) {
                  Gmax2 = -G[j];
               }
               if (grad_diff > 0)
               {
                  double obj_diff;
                  final double quad_coef = QD[i] + QD[j] + 2.0 * y[i] * Q_i[j];
                  if (quad_coef > 0) {
                     obj_diff = -(grad_diff * grad_diff) / quad_coef;
                  }
                  else {
                     obj_diff = -(grad_diff * grad_diff) / 1e-12;
                  }
                  
                  if (obj_diff <= obj_diff_min)
                  {
                     Gmin_idx = j;
                     obj_diff_min = obj_diff;
                  }
               }
            }
         }
      }
      
      if (Gmax + Gmax2 < eps) {
         return 1;
      }
      
      working_set[0] = Gmax_idx;
      working_set[1] = Gmin_idx;
      return 0;
   }
   
   private boolean be_shrunk(final int i, final double Gmax1, final double Gmax2)
   {
      if (is_upper_bound(i))
      {
         if (y[i] == +1) {
            return -G[i] > Gmax1;
         }
         else {
            return -G[i] > Gmax2;
         }
      }
      else if (is_lower_bound(i))
      {
         if (y[i] == +1) {
            return G[i] > Gmax2;
         }
         else {
            return G[i] > Gmax1;
         }
      }
      else {
         return false;
      }
   }
   
   void do_shrinking()
   {
      int i;
      double Gmax1 = -INF;		// max { -y_i * grad(f)_i | i in I_up(\alpha) }
      double Gmax2 = -INF;		// max { y_i * grad(f)_i | i in I_low(\alpha) }
      
      // find maximal violating pair first
      for (i = 0; i < active_size; i++)
      {
         if (y[i] == +1)
         {
            if (!is_upper_bound(i))
            {
               if (-G[i] >= Gmax1) {
                  Gmax1 = -G[i];
               }
            }
            if (!is_lower_bound(i))
            {
               if (G[i] >= Gmax2) {
                  Gmax2 = G[i];
               }
            }
         }
         else
         {
            if (!is_upper_bound(i))
            {
               if (-G[i] >= Gmax2) {
                  Gmax2 = -G[i];
               }
            }
            if (!is_lower_bound(i))
            {
               if (G[i] >= Gmax1) {
                  Gmax1 = G[i];
               }
            }
         }
      }
      
      if (unshrink == false && Gmax1 + Gmax2 <= eps * 10)
      {
         unshrink = true;
         reconstruct_gradient();
         active_size = l;
      }
      
      for (i = 0; i < active_size; i++) {
         if (be_shrunk(i, Gmax1, Gmax2))
         {
            active_size--;
            while (active_size > i)
            {
               if (!be_shrunk(active_size, Gmax1, Gmax2))
               {
                  swap_index(i, active_size);
                  break;
               }
               active_size--;
            }
         }
      }
   }
   
   double calculate_rho()
   {
      double r;
      int nr_free = 0;
      double ub = INF, lb = -INF, sum_free = 0;
      for (int i = 0; i < active_size; i++)
      {
         final double yG = y[i] * G[i];
         
         if (is_lower_bound(i))
         {
            if (y[i] > 0) {
               ub = Math.min(ub, yG);
            }
            else {
               lb = Math.max(lb, yG);
            }
         }
         else if (is_upper_bound(i))
         {
            if (y[i] < 0) {
               ub = Math.min(ub, yG);
            }
            else {
               lb = Math.max(lb, yG);
            }
         }
         else
         {
            ++nr_free;
            sum_free += yG;
         }
      }
      
      if (nr_free > 0) {
         r = sum_free / nr_free;
      }
      else {
         r = (ub + lb) / 2;
      }
      
      return r;
   }
   
}

//
// Solver for nu-svm classification and regression
//
// additional constraint: e^T \alpha = constant
//
final class Solver_NU extends Solver
{
   private SolutionInfo si;
   
   @Override
   void Solve(final int l, final QMatrix Q, final double[] p, final byte[] y,
         final double[] alpha, final double Cp, final double Cn, final double eps,
         final SolutionInfo si, final int shrinking)
   {
      this.si = si;
      super.Solve(l, Q, p, y, alpha, Cp, Cn, eps, si, shrinking);
   }
   
   // return 1 if already optimal, return 0 otherwise
   @Override
   int select_working_set(final int[] working_set)
   {
      // return i,j such that y_i = y_j and
      // i: maximizes -y_i * grad(f)_i, i in I_up(\alpha)
      // j: minimizes the decrease of obj value
      //    (if quadratic coefficeint <= 0, replace it with tau)
      //    -y_j*grad(f)_j < -y_i*grad(f)_i, j in I_low(\alpha)
      
      double Gmaxp = -INF;
      double Gmaxp2 = -INF;
      int Gmaxp_idx = -1;
      
      double Gmaxn = -INF;
      double Gmaxn2 = -INF;
      int Gmaxn_idx = -1;
      
      int Gmin_idx = -1;
      double obj_diff_min = INF;
      
      for (int t = 0; t < active_size; t++) {
         if (y[t] == +1)
         {
            if (!is_upper_bound(t)) {
               if (-G[t] >= Gmaxp)
               {
                  Gmaxp = -G[t];
                  Gmaxp_idx = t;
               }
            }
         }
         else
         {
            if (!is_lower_bound(t)) {
               if (G[t] >= Gmaxn)
               {
                  Gmaxn = G[t];
                  Gmaxn_idx = t;
               }
            }
         }
      }
      
      final int ip = Gmaxp_idx;
      final int in = Gmaxn_idx;
      float[] Q_ip = null;
      float[] Q_in = null;
      if (ip != -1) {
         Q_ip = Q.get_Q(ip, active_size);
      }
      if (in != -1) {
         Q_in = Q.get_Q(in, active_size);
      }
      
      for (int j = 0; j < active_size; j++)
      {
         if (y[j] == +1)
         {
            if (!is_lower_bound(j))
            {
               final double grad_diff = Gmaxp + G[j];
               if (G[j] >= Gmaxp2) {
                  Gmaxp2 = G[j];
               }
               if (grad_diff > 0)
               {
                  double obj_diff;
                  final double quad_coef = QD[ip] + QD[j] - 2 * Q_ip[j];
                  if (quad_coef > 0) {
                     obj_diff = -(grad_diff * grad_diff) / quad_coef;
                  }
                  else {
                     obj_diff = -(grad_diff * grad_diff) / 1e-12;
                  }
                  
                  if (obj_diff <= obj_diff_min)
                  {
                     Gmin_idx = j;
                     obj_diff_min = obj_diff;
                  }
               }
            }
         }
         else
         {
            if (!is_upper_bound(j))
            {
               final double grad_diff = Gmaxn - G[j];
               if (-G[j] >= Gmaxn2) {
                  Gmaxn2 = -G[j];
               }
               if (grad_diff > 0)
               {
                  double obj_diff;
                  final double quad_coef = QD[in] + QD[j] - 2 * Q_in[j];
                  if (quad_coef > 0) {
                     obj_diff = -(grad_diff * grad_diff) / quad_coef;
                  }
                  else {
                     obj_diff = -(grad_diff * grad_diff) / 1e-12;
                  }
                  
                  if (obj_diff <= obj_diff_min)
                  {
                     Gmin_idx = j;
                     obj_diff_min = obj_diff;
                  }
               }
            }
         }
      }
      
      if (Math.max(Gmaxp + Gmaxp2, Gmaxn + Gmaxn2) < eps) {
         return 1;
      }
      
      if (y[Gmin_idx] == +1) {
         working_set[0] = Gmaxp_idx;
      }
      else {
         working_set[0] = Gmaxn_idx;
      }
      working_set[1] = Gmin_idx;
      
      return 0;
   }
   
   private boolean be_shrunk(final int i, final double Gmax1, final double Gmax2, final double Gmax3, final double Gmax4)
   {
      if (is_upper_bound(i))
      {
         if (y[i] == +1) {
            return -G[i] > Gmax1;
         }
         else {
            return -G[i] > Gmax4;
         }
      }
      else if (is_lower_bound(i))
      {
         if (y[i] == +1) {
            return G[i] > Gmax2;
         }
         else {
            return G[i] > Gmax3;
         }
      }
      else {
         return false;
      }
   }
   
   @Override
   void do_shrinking()
   {
      double Gmax1 = -INF;	// max { -y_i * grad(f)_i | y_i = +1, i in I_up(\alpha) }
      double Gmax2 = -INF;	// max { y_i * grad(f)_i | y_i = +1, i in I_low(\alpha) }
      double Gmax3 = -INF;	// max { -y_i * grad(f)_i | y_i = -1, i in I_up(\alpha) }
      double Gmax4 = -INF;	// max { y_i * grad(f)_i | y_i = -1, i in I_low(\alpha) }
      
      // find maximal violating pair first
      int i;
      for (i = 0; i < active_size; i++)
      {
         if (!is_upper_bound(i))
         {
            if (y[i] == +1)
            {
               if (-G[i] > Gmax1) {
                  Gmax1 = -G[i];
               }
            }
            else if (-G[i] > Gmax4) {
               Gmax4 = -G[i];
            }
         }
         if (!is_lower_bound(i))
         {
            if (y[i] == +1)
            {
               if (G[i] > Gmax2) {
                  Gmax2 = G[i];
               }
            }
            else if (G[i] > Gmax3) {
               Gmax3 = G[i];
            }
         }
      }
      
      if (unshrink == false && Math.max(Gmax1 + Gmax2, Gmax3 + Gmax4) <= eps * 10)
      {
         unshrink = true;
         reconstruct_gradient();
         active_size = l;
      }
      
      for (i = 0; i < active_size; i++) {
         if (be_shrunk(i, Gmax1, Gmax2, Gmax3, Gmax4))
         {
            active_size--;
            while (active_size > i)
            {
               if (!be_shrunk(active_size, Gmax1, Gmax2, Gmax3, Gmax4))
               {
                  swap_index(i, active_size);
                  break;
               }
               active_size--;
            }
         }
      }
   }
   
   @Override
   double calculate_rho()
   {
      int nr_free1 = 0, nr_free2 = 0;
      double ub1 = INF, ub2 = INF;
      double lb1 = -INF, lb2 = -INF;
      double sum_free1 = 0, sum_free2 = 0;
      
      for (int i = 0; i < active_size; i++)
      {
         if (y[i] == +1)
         {
            if (is_lower_bound(i)) {
               ub1 = Math.min(ub1, G[i]);
            }
            else if (is_upper_bound(i)) {
               lb1 = Math.max(lb1, G[i]);
            }
            else
            {
               ++nr_free1;
               sum_free1 += G[i];
            }
         }
         else
         {
            if (is_lower_bound(i)) {
               ub2 = Math.min(ub2, G[i]);
            }
            else if (is_upper_bound(i)) {
               lb2 = Math.max(lb2, G[i]);
            }
            else
            {
               ++nr_free2;
               sum_free2 += G[i];
            }
         }
      }
      
      double r1, r2;
      if (nr_free1 > 0) {
         r1 = sum_free1 / nr_free1;
      }
      else {
         r1 = (ub1 + lb1) / 2;
      }
      
      if (nr_free2 > 0) {
         r2 = sum_free2 / nr_free2;
      }
      else {
         r2 = (ub2 + lb2) / 2;
      }
      
      si.r = (r1 + r2) / 2;
      return (r1 - r2) / 2;
   }
}

//
// Q matrices for various formulations
//
class SVC_Q extends Kernel
{
   private final byte[] y;
   private final Cache cache;
   private final double[] QD;
   
   SVC_Q(final svm_problem prob, final svm_parameter param, final byte[] y_)
   {
      super(prob.l, prob.x, param);
      y = y_.clone();
      cache = new Cache(prob.l, (long) (param.cache_size * (1 << 20)));
      QD = new double[prob.l];
      for (int i = 0; i < prob.l; i++) {
         QD[i] = kernel_function(i, i);
      }
   }
   
   @Override
   float[] get_Q(final int i, final int len)
   {
      final float[][] data = new float[1][];
      int start, j;
      if ((start = cache.get_data(i, data, len)) < len)
      {
         for (j = start; j < len; j++) {
            data[0][j] = (float) (y[i] * y[j] * kernel_function(i, j));
         }
      }
      return data[0];
   }
   
   @Override
   double[] get_QD()
   {
      return QD;
   }
   
   @Override
   void swap_index(final int i, final int j)
   {
      cache.swap_index(i, j);
      super.swap_index(i, j);
      do {
         final byte _ = y[i];
         y[i] = y[j];
         y[j] = _;
      } while (false);
      do {
         final double _ = QD[i];
         QD[i] = QD[j];
         QD[j] = _;
      } while (false);
   }
}

class ONE_CLASS_Q extends Kernel
{
   private final Cache cache;
   private final double[] QD;
   
   ONE_CLASS_Q(final svm_problem prob, final svm_parameter param)
   {
      super(prob.l, prob.x, param);
      cache = new Cache(prob.l, (long) (param.cache_size * (1 << 20)));
      QD = new double[prob.l];
      for (int i = 0; i < prob.l; i++) {
         QD[i] = kernel_function(i, i);
      }
   }
   
   @Override
   float[] get_Q(final int i, final int len)
   {
      final float[][] data = new float[1][];
      int start, j;
      if ((start = cache.get_data(i, data, len)) < len)
      {
         for (j = start; j < len; j++) {
            data[0][j] = (float) kernel_function(i, j);
         }
      }
      return data[0];
   }
   
   @Override
   double[] get_QD()
   {
      return QD;
   }
   
   @Override
   void swap_index(final int i, final int j)
   {
      cache.swap_index(i, j);
      super.swap_index(i, j);
      do {
         final double _ = QD[i];
         QD[i] = QD[j];
         QD[j] = _;
      } while (false);
   }
}

class SVR_Q extends Kernel
{
   private final int l;
   private final Cache cache;
   private final byte[] sign;
   private final int[] index;
   private int next_buffer;
   private final float[][] buffer;
   private final double[] QD;
   
   SVR_Q(final svm_problem prob, final svm_parameter param)
   {
      super(prob.l, prob.x, param);
      l = prob.l;
      cache = new Cache(l, (long) (param.cache_size * (1 << 20)));
      QD = new double[2 * l];
      sign = new byte[2 * l];
      index = new int[2 * l];
      for (int k = 0; k < l; k++)
      {
         sign[k] = 1;
         sign[k + l] = -1;
         index[k] = k;
         index[k + l] = k;
         QD[k] = kernel_function(k, k);
         QD[k + l] = QD[k];
      }
      buffer = new float[2][2 * l];
      next_buffer = 0;
   }
   
   @Override
   void swap_index(final int i, final int j)
   {
      do {
         final byte _ = sign[i];
         sign[i] = sign[j];
         sign[j] = _;
      } while (false);
      do {
         final int _ = index[i];
         index[i] = index[j];
         index[j] = _;
      } while (false);
      do {
         final double _ = QD[i];
         QD[i] = QD[j];
         QD[j] = _;
      } while (false);
   }
   
   @Override
   float[] get_Q(final int i, final int len)
   {
      final float[][] data = new float[1][];
      int j;
      final int real_i = index[i];
      if (cache.get_data(real_i, data, l) < l)
      {
         for (j = 0; j < l; j++) {
            data[0][j] = (float) kernel_function(real_i, j);
         }
      }
      
      // reorder and copy
      final float buf[] = buffer[next_buffer];
      next_buffer = 1 - next_buffer;
      final byte si = sign[i];
      for (j = 0; j < len; j++) {
         buf[j] = (float) si * sign[j] * data[0][index[j]];
      }
      return buf;
   }
   
   @Override
   double[] get_QD()
   {
      return QD;
   }
}

public class svm {
   //
   // construct and solve various formulations
   //
   public static final int LIBSVM_VERSION = 312;
   public static final Random rand = new Random();
   
   private static svm_print_interface svm_print_stdout = new svm_print_interface()
   {
      @Override
      public void print(final String s)
      {
         //			System.out.print(s);
         //			System.out.flush();
      }
   };
   
   private static svm_print_interface svm_print_string = svm_print_stdout;
   
   static void info(final String s)
   {
      svm_print_string.print(s);
   }
   
   private static void solve_c_svc(final svm_problem prob, final svm_parameter param,
         final double[] alpha, final Solver.SolutionInfo si,
         final double Cp, final double Cn)
   {
      final int l = prob.l;
      final double[] minus_ones = new double[l];
      final byte[] y = new byte[l];
      
      int i;
      
      for (i = 0; i < l; i++)
      {
         alpha[i] = 0;
         minus_ones[i] = -1;
         if (prob.y[i] > 0) {
            y[i] = +1;
         }
         else {
            y[i] = -1;
         }
      }
      
      final Solver s = new Solver();
      s.Solve(l, new SVC_Q(prob, param, y), minus_ones, y,
            alpha, Cp, Cn, param.eps, si, param.shrinking);
      
      double sum_alpha = 0;
      for (i = 0; i < l; i++) {
         sum_alpha += alpha[i];
      }
      
      if (Cp == Cn) {
         svm.info("nu = " + sum_alpha / (Cp * prob.l) + "\n");
      }
      
      for (i = 0; i < l; i++) {
         alpha[i] *= y[i];
      }
   }
   
   private static void solve_nu_svc(final svm_problem prob, final svm_parameter param,
         final double[] alpha, final Solver.SolutionInfo si)
   {
      int i;
      final int l = prob.l;
      final double nu = param.nu;
      
      final byte[] y = new byte[l];
      
      for (i = 0; i < l; i++) {
         if (prob.y[i] > 0) {
            y[i] = +1;
         }
         else {
            y[i] = -1;
         }
      }
      
      double sum_pos = nu * l / 2;
      double sum_neg = nu * l / 2;
      
      for (i = 0; i < l; i++) {
         if (y[i] == +1)
         {
            alpha[i] = Math.min(1.0, sum_pos);
            sum_pos -= alpha[i];
         }
         else
         {
            alpha[i] = Math.min(1.0, sum_neg);
            sum_neg -= alpha[i];
         }
      }
      
      final double[] zeros = new double[l];
      
      for (i = 0; i < l; i++) {
         zeros[i] = 0;
      }
      
      final Solver_NU s = new Solver_NU();
      s.Solve(l, new SVC_Q(prob, param, y), zeros, y,
            alpha, 1.0, 1.0, param.eps, si, param.shrinking);
      final double r = si.r;
      
      svm.info("C = " + 1 / r + "\n");
      
      for (i = 0; i < l; i++) {
         alpha[i] *= y[i] / r;
      }
      
      si.rho /= r;
      si.obj /= r * r;
      si.upper_bound_p = 1 / r;
      si.upper_bound_n = 1 / r;
   }
   
   private static void solve_one_class(final svm_problem prob, final svm_parameter param,
         final double[] alpha, final Solver.SolutionInfo si)
   {
      final int l = prob.l;
      final double[] zeros = new double[l];
      final byte[] ones = new byte[l];
      int i;
      
      final int n = (int) (param.nu * prob.l);	// # of alpha's at upper bound
      
      for (i = 0; i < n; i++) {
         alpha[i] = 1;
      }
      if (n < prob.l) {
         alpha[n] = param.nu * prob.l - n;
      }
      for (i = n + 1; i < l; i++) {
         alpha[i] = 0;
      }
      
      for (i = 0; i < l; i++)
      {
         zeros[i] = 0;
         ones[i] = 1;
      }
      
      final Solver s = new Solver();
      s.Solve(l, new ONE_CLASS_Q(prob, param), zeros, ones,
            alpha, 1.0, 1.0, param.eps, si, param.shrinking);
   }
   
   private static void solve_epsilon_svr(final svm_problem prob, final svm_parameter param,
         final double[] alpha, final Solver.SolutionInfo si)
   {
      final int l = prob.l;
      final double[] alpha2 = new double[2 * l];
      final double[] linear_term = new double[2 * l];
      final byte[] y = new byte[2 * l];
      int i;
      
      for (i = 0; i < l; i++)
      {
         alpha2[i] = 0;
         linear_term[i] = param.p - prob.y[i];
         y[i] = 1;
         
         alpha2[i + l] = 0;
         linear_term[i + l] = param.p + prob.y[i];
         y[i + l] = -1;
      }
      
      final Solver s = new Solver();
      s.Solve(2 * l, new SVR_Q(prob, param), linear_term, y,
            alpha2, param.C, param.C, param.eps, si, param.shrinking);
      
      double sum_alpha = 0;
      for (i = 0; i < l; i++)
      {
         alpha[i] = alpha2[i] - alpha2[i + l];
         sum_alpha += Math.abs(alpha[i]);
      }
      svm.info("nu = " + sum_alpha / (param.C * l) + "\n");
   }
   
   private static void solve_nu_svr(final svm_problem prob, final svm_parameter param,
         final double[] alpha, final Solver.SolutionInfo si)
   {
      final int l = prob.l;
      final double C = param.C;
      final double[] alpha2 = new double[2 * l];
      final double[] linear_term = new double[2 * l];
      final byte[] y = new byte[2 * l];
      int i;
      
      double sum = C * param.nu * l / 2;
      for (i = 0; i < l; i++)
      {
         alpha2[i] = alpha2[i + l] = Math.min(sum, C);
         sum -= alpha2[i];
         
         linear_term[i] = -prob.y[i];
         y[i] = 1;
         
         linear_term[i + l] = prob.y[i];
         y[i + l] = -1;
      }
      
      final Solver_NU s = new Solver_NU();
      s.Solve(2 * l, new SVR_Q(prob, param), linear_term, y,
            alpha2, C, C, param.eps, si, param.shrinking);
      
      svm.info("epsilon = " + -si.r + "\n");
      
      for (i = 0; i < l; i++) {
         alpha[i] = alpha2[i] - alpha2[i + l];
      }
   }
   
   //
   // decision_function
   //
   static class decision_function
   {
      double[] alpha;
      double rho;
   };
   
   static decision_function svm_train_one(
         final svm_problem prob, final svm_parameter param,
         final double Cp, final double Cn)
   {
      final double[] alpha = new double[prob.l];
      final Solver.SolutionInfo si = new Solver.SolutionInfo();
      switch (param.svm_type)
      {
         case svm_parameter.C_SVC:
            solve_c_svc(prob, param, alpha, si, Cp, Cn);
            break;
         case svm_parameter.NU_SVC:
            solve_nu_svc(prob, param, alpha, si);
            break;
         case svm_parameter.ONE_CLASS:
            solve_one_class(prob, param, alpha, si);
            break;
         case svm_parameter.EPSILON_SVR:
            solve_epsilon_svr(prob, param, alpha, si);
            break;
         case svm_parameter.NU_SVR:
            solve_nu_svr(prob, param, alpha, si);
            break;
      }
      
      svm.info("obj = " + si.obj + ", rho = " + si.rho + "\n");
      
      // output SVs
      
      int nSV = 0;
      int nBSV = 0;
      for (int i = 0; i < prob.l; i++)
      {
         if (Math.abs(alpha[i]) > 0)
         {
            ++nSV;
            if (prob.y[i] > 0)
            {
               if (Math.abs(alpha[i]) >= si.upper_bound_p) {
                  ++nBSV;
               }
            }
            else
            {
               if (Math.abs(alpha[i]) >= si.upper_bound_n) {
                  ++nBSV;
               }
            }
         }
      }
      
      svm.info("nSV = " + nSV + ", nBSV = " + nBSV + "\n");
      
      final decision_function f = new decision_function();
      f.alpha = alpha;
      f.rho = si.rho;
      return f;
   }
   
   // Platt's binary SVM Probablistic Output: an improvement from Lin et al.
   private static void sigmoid_train(final int l, final double[] dec_values, final double[] labels,
         final double[] probAB)
   {
      double A, B;
      double prior1 = 0, prior0 = 0;
      int i;
      
      for (i = 0; i < l; i++) {
         if (labels[i] > 0) {
            prior1 += 1;
         }
         else {
            prior0 += 1;
         }
      }
      
      final int max_iter = 100;	// Maximal number of iterations
      final double min_step = 1e-10;	// Minimal step taken in line search
      final double sigma = 1e-12;	// For numerically strict PD of Hessian
      final double eps = 1e-5;
      final double hiTarget = (prior1 + 1.0) / (prior1 + 2.0);
      final double loTarget = 1 / (prior0 + 2.0);
      final double[] t = new double[l];
      double fApB, p, q, h11, h22, h21, g1, g2, det, dA, dB, gd, stepsize;
      double newA, newB, newf, d1, d2;
      int iter;
      
      // Initial Point and Initial Fun Value
      A = 0.0;
      B = Math.log((prior0 + 1.0) / (prior1 + 1.0));
      double fval = 0.0;
      
      for (i = 0; i < l; i++)
      {
         if (labels[i] > 0) {
            t[i] = hiTarget;
         }
         else {
            t[i] = loTarget;
         }
         fApB = dec_values[i] * A + B;
         if (fApB >= 0) {
            fval += t[i] * fApB + Math.log(1 + Math.exp(-fApB));
         }
         else {
            fval += (t[i] - 1) * fApB + Math.log(1 + Math.exp(fApB));
         }
      }
      for (iter = 0; iter < max_iter; iter++)
      {
         // Update Gradient and Hessian (use H' = H + sigma I)
         h11 = sigma; // numerically ensures strict PD
         h22 = sigma;
         h21 = 0.0;
         g1 = 0.0;
         g2 = 0.0;
         for (i = 0; i < l; i++)
         {
            fApB = dec_values[i] * A + B;
            if (fApB >= 0)
            {
               p = Math.exp(-fApB) / (1.0 + Math.exp(-fApB));
               q = 1.0 / (1.0 + Math.exp(-fApB));
            }
            else
            {
               p = 1.0 / (1.0 + Math.exp(fApB));
               q = Math.exp(fApB) / (1.0 + Math.exp(fApB));
            }
            d2 = p * q;
            h11 += dec_values[i] * dec_values[i] * d2;
            h22 += d2;
            h21 += dec_values[i] * d2;
            d1 = t[i] - p;
            g1 += dec_values[i] * d1;
            g2 += d1;
         }
         
         // Stopping Criteria
         if (Math.abs(g1) < eps && Math.abs(g2) < eps) {
            break;
         }
         
         // Finding Newton direction: -inv(H') * g
         det = h11 * h22 - h21 * h21;
         dA = -(h22 * g1 - h21 * g2) / det;
         dB = -(-h21 * g1 + h11 * g2) / det;
         gd = g1 * dA + g2 * dB;
         
         stepsize = 1;		// Line Search
         while (stepsize >= min_step)
         {
            newA = A + stepsize * dA;
            newB = B + stepsize * dB;
            
            // New function value
            newf = 0.0;
            for (i = 0; i < l; i++)
            {
               fApB = dec_values[i] * newA + newB;
               if (fApB >= 0) {
                  newf += t[i] * fApB + Math.log(1 + Math.exp(-fApB));
               }
               else {
                  newf += (t[i] - 1) * fApB + Math.log(1 + Math.exp(fApB));
               }
            }
            // Check sufficient decrease
            if (newf < fval + 0.0001 * stepsize * gd)
            {
               A = newA;
               B = newB;
               fval = newf;
               break;
            }
            else {
               stepsize = stepsize / 2.0;
            }
         }
         
         if (stepsize < min_step)
         {
            svm.info("Line search fails in two-class probability estimates\n");
            break;
         }
      }
      
      if (iter >= max_iter) {
         svm.info("Reaching maximal iterations in two-class probability estimates\n");
      }
      probAB[0] = A;
      probAB[1] = B;
   }
   
   private static double sigmoid_predict(final double decision_value, final double A, final double B)
   {
      final double fApB = decision_value * A + B;
      if (fApB >= 0) {
         return Math.exp(-fApB) / (1.0 + Math.exp(-fApB));
      }
      else {
         return 1.0 / (1 + Math.exp(fApB));
      }
   }
   
   // Method 2 from the multiclass_prob paper by Wu, Lin, and Weng
   private static void multiclass_probability(final int k, final double[][] r, final double[] p)
   {
      int t, j;
      int iter = 0;
      final int max_iter = Math.max(100, k);
      final double[][] Q = new double[k][k];
      final double[] Qp = new double[k];
      double pQp;
      final double eps = 0.005 / k;
      
      for (t = 0; t < k; t++)
      {
         p[t] = 1.0 / k;  // Valid if k = 1
         Q[t][t] = 0;
         for (j = 0; j < t; j++)
         {
            Q[t][t] += r[j][t] * r[j][t];
            Q[t][j] = Q[j][t];
         }
         for (j = t + 1; j < k; j++)
         {
            Q[t][t] += r[j][t] * r[j][t];
            Q[t][j] = -r[j][t] * r[t][j];
         }
      }
      for (iter = 0; iter < max_iter; iter++)
      {
         // stopping condition, recalculate QP,pQP for numerical accuracy
         pQp = 0;
         for (t = 0; t < k; t++)
         {
            Qp[t] = 0;
            for (j = 0; j < k; j++) {
               Qp[t] += Q[t][j] * p[j];
            }
            pQp += p[t] * Qp[t];
         }
         double max_error = 0;
         for (t = 0; t < k; t++)
         {
            final double error = Math.abs(Qp[t] - pQp);
            if (error > max_error) {
               max_error = error;
            }
         }
         if (max_error < eps) {
            break;
         }
         
         for (t = 0; t < k; t++)
         {
            final double diff = (-Qp[t] + pQp) / Q[t][t];
            p[t] += diff;
            pQp = (pQp + diff * (diff * Q[t][t] + 2 * Qp[t])) / (1 + diff) / (1 + diff);
            for (j = 0; j < k; j++)
            {
               Qp[j] = (Qp[j] + diff * Q[t][j]) / (1 + diff);
               p[j] /= 1 + diff;
            }
         }
      }
      if (iter >= max_iter) {
         svm.info("Exceeds max_iter in multiclass_prob\n");
      }
   }
   
   // Cross-validation decision values for probability estimates
   private static void svm_binary_svc_probability(final svm_problem prob, final svm_parameter param, final double Cp, final double Cn, final double[] probAB)
   {
      int i;
      final int nr_fold = 5;
      final int[] perm = new int[prob.l];
      final double[] dec_values = new double[prob.l];
      
      // random shuffle
      for (i = 0; i < prob.l; i++) {
         perm[i] = i;
      }
      for (i = 0; i < prob.l; i++)
      {
         final int j = i + rand.nextInt(prob.l - i);
         do {
            final int _ = perm[i];
            perm[i] = perm[j];
            perm[j] = _;
         } while (false);
      }
      for (i = 0; i < nr_fold; i++)
      {
         final int begin = i * prob.l / nr_fold;
         final int end = (i + 1) * prob.l / nr_fold;
         int j, k;
         final svm_problem subprob = new svm_problem();
         
         subprob.l = prob.l - (end - begin);
         subprob.x = new svm_node[subprob.l][];
         subprob.y = new double[subprob.l];
         
         k = 0;
         for (j = 0; j < begin; j++)
         {
            subprob.x[k] = prob.x[perm[j]];
            subprob.y[k] = prob.y[perm[j]];
            ++k;
         }
         for (j = end; j < prob.l; j++)
         {
            subprob.x[k] = prob.x[perm[j]];
            subprob.y[k] = prob.y[perm[j]];
            ++k;
         }
         int p_count = 0, n_count = 0;
         for (j = 0; j < k; j++) {
            if (subprob.y[j] > 0) {
               p_count++;
            }
            else {
               n_count++;
            }
         }
         
         if (p_count == 0 && n_count == 0) {
            for (j = begin; j < end; j++) {
               dec_values[perm[j]] = 0;
            }
         }
         else if (p_count > 0 && n_count == 0) {
            for (j = begin; j < end; j++) {
               dec_values[perm[j]] = 1;
            }
         }
         else if (p_count == 0 && n_count > 0) {
            for (j = begin; j < end; j++) {
               dec_values[perm[j]] = -1;
            }
         }
         else
         {
            final svm_parameter subparam = (svm_parameter) param.clone();
            subparam.probability = 0;
            subparam.C = 1.0;
            subparam.nr_weight = 2;
            subparam.weight_label = new int[2];
            subparam.weight = new double[2];
            subparam.weight_label[0] = +1;
            subparam.weight_label[1] = -1;
            subparam.weight[0] = Cp;
            subparam.weight[1] = Cn;
            final svm_model submodel = svm_train(subprob, subparam);
            for (j = begin; j < end; j++)
            {
               final double[] dec_value = new double[1];
               svm_predict_values(submodel, prob.x[perm[j]], dec_value);
               dec_values[perm[j]] = dec_value[0];
               // ensure +1 -1 order; reason not using CV subroutine
               dec_values[perm[j]] *= submodel.label[0];
            }
         }
      }
      sigmoid_train(prob.l, dec_values, prob.y, probAB);
   }
   
   // Return parameter of a Laplace distribution 
   private static double svm_svr_probability(final svm_problem prob, final svm_parameter param)
   {
      int i;
      final int nr_fold = 5;
      final double[] ymv = new double[prob.l];
      double mae = 0;
      
      final svm_parameter newparam = (svm_parameter) param.clone();
      newparam.probability = 0;
      svm_cross_validation(prob, newparam, nr_fold, ymv);
      for (i = 0; i < prob.l; i++)
      {
         ymv[i] = prob.y[i] - ymv[i];
         mae += Math.abs(ymv[i]);
      }
      mae /= prob.l;
      final double std = Math.sqrt(2 * mae * mae);
      int count = 0;
      mae = 0;
      for (i = 0; i < prob.l; i++) {
         if (Math.abs(ymv[i]) > 5 * std) {
            count = count + 1;
         }
         else {
            mae += Math.abs(ymv[i]);
         }
      }
      mae /= prob.l - count;
      svm.info("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=" + mae + "\n");
      return mae;
   }
   
   // label: label name, start: begin of each class, count: #data of classes, perm: indices to the original data
   // perm, length l, must be allocated before calling this subroutine
   private static void svm_group_classes(final svm_problem prob, final int[] nr_class_ret, final int[][] label_ret, final int[][] start_ret, final int[][] count_ret, final int[] perm)
   {
      final int l = prob.l;
      int max_nr_class = 16;
      int nr_class = 0;
      int[] label = new int[max_nr_class];
      int[] count = new int[max_nr_class];
      final int[] data_label = new int[l];
      int i;
      
      for (i = 0; i < l; i++)
      {
         final int this_label = (int) prob.y[i];
         int j;
         for (j = 0; j < nr_class; j++)
         {
            if (this_label == label[j])
            {
               ++count[j];
               break;
            }
         }
         data_label[i] = j;
         if (j == nr_class)
         {
            if (nr_class == max_nr_class)
            {
               max_nr_class *= 2;
               int[] new_data = new int[max_nr_class];
               System.arraycopy(label, 0, new_data, 0, label.length);
               label = new_data;
               new_data = new int[max_nr_class];
               System.arraycopy(count, 0, new_data, 0, count.length);
               count = new_data;
            }
            label[nr_class] = this_label;
            count[nr_class] = 1;
            ++nr_class;
         }
      }
      
      final int[] start = new int[nr_class];
      start[0] = 0;
      for (i = 1; i < nr_class; i++) {
         start[i] = start[i - 1] + count[i - 1];
      }
      for (i = 0; i < l; i++)
      {
         perm[start[data_label[i]]] = i;
         ++start[data_label[i]];
      }
      start[0] = 0;
      for (i = 1; i < nr_class; i++) {
         start[i] = start[i - 1] + count[i - 1];
      }
      
      nr_class_ret[0] = nr_class;
      label_ret[0] = label;
      start_ret[0] = start;
      count_ret[0] = count;
   }
   
   //
   // Interface functions
   //
   public static svm_model svm_train(final svm_problem prob, final svm_parameter param)
   {
      final svm_model model = new svm_model();
      model.param = param;
      
      if (param.svm_type == svm_parameter.ONE_CLASS ||
            param.svm_type == svm_parameter.EPSILON_SVR ||
            param.svm_type == svm_parameter.NU_SVR)
      {
         // regression or one-class-svm
         model.nr_class = 2;
         model.label = null;
         model.nSV = null;
         model.probA = null;
         model.probB = null;
         model.sv_coef = new double[1][];
         
         if (param.probability == 1 &&
               (param.svm_type == svm_parameter.EPSILON_SVR ||
               param.svm_type == svm_parameter.NU_SVR))
         {
            model.probA = new double[1];
            model.probA[0] = svm_svr_probability(prob, param);
         }
         
         final decision_function f = svm_train_one(prob, param, 0, 0);
         model.rho = new double[1];
         model.rho[0] = f.rho;
         
         int nSV = 0;
         int i;
         for (i = 0; i < prob.l; i++) {
            if (Math.abs(f.alpha[i]) > 0) {
               ++nSV;
            }
         }
         model.l = nSV;
         model.SV = new svm_node[nSV][];
         model.sv_coef[0] = new double[nSV];
         int j = 0;
         for (i = 0; i < prob.l; i++) {
            if (Math.abs(f.alpha[i]) > 0)
            {
               model.SV[j] = prob.x[i];
               model.sv_coef[0][j] = f.alpha[i];
               ++j;
            }
         }
      }
      else
      {
         // classification
         final int l = prob.l;
         final int[] tmp_nr_class = new int[1];
         final int[][] tmp_label = new int[1][];
         final int[][] tmp_start = new int[1][];
         final int[][] tmp_count = new int[1][];
         final int[] perm = new int[l];
         
         // group training data of the same class
         svm_group_classes(prob, tmp_nr_class, tmp_label, tmp_start, tmp_count, perm);
         final int nr_class = tmp_nr_class[0];
         final int[] label = tmp_label[0];
         final int[] start = tmp_start[0];
         final int[] count = tmp_count[0];
         
         if (nr_class == 1) {
            svm.info("WARNING: training data in only one class. See README for details.\n");
         }
         
         final svm_node[][] x = new svm_node[l][];
         int i;
         for (i = 0; i < l; i++) {
            x[i] = prob.x[perm[i]];
         }
         
         // calculate weighted C
         
         final double[] weighted_C = new double[nr_class];
         for (i = 0; i < nr_class; i++) {
            weighted_C[i] = param.C;
         }
         for (i = 0; i < param.nr_weight; i++)
         {
            int j;
            for (j = 0; j < nr_class; j++) {
               if (param.weight_label[i] == label[j]) {
                  break;
               }
            }
            if (j == nr_class) {
               System.err.print("WARNING: class label " + param.weight_label[i] + " specified in weight is not found\n");
            }
            else {
               weighted_C[j] *= param.weight[i];
            }
         }
         
         // train k*(k-1)/2 models
         
         final boolean[] nonzero = new boolean[l];
         for (i = 0; i < l; i++) {
            nonzero[i] = false;
         }
         final decision_function[] f = new decision_function[nr_class * (nr_class - 1) / 2];
         
         double[] probA = null, probB = null;
         if (param.probability == 1)
         {
            probA = new double[nr_class * (nr_class - 1) / 2];
            probB = new double[nr_class * (nr_class - 1) / 2];
         }
         
         int p = 0;
         for (i = 0; i < nr_class; i++) {
            for (int j = i + 1; j < nr_class; j++)
            {
               final svm_problem sub_prob = new svm_problem();
               final int si = start[i], sj = start[j];
               final int ci = count[i], cj = count[j];
               sub_prob.l = ci + cj;
               sub_prob.x = new svm_node[sub_prob.l][];
               sub_prob.y = new double[sub_prob.l];
               int k;
               for (k = 0; k < ci; k++)
               {
                  sub_prob.x[k] = x[si + k];
                  sub_prob.y[k] = +1;
               }
               for (k = 0; k < cj; k++)
               {
                  sub_prob.x[ci + k] = x[sj + k];
                  sub_prob.y[ci + k] = -1;
               }
               
               if (param.probability == 1)
               {
                  final double[] probAB = new double[2];
                  svm_binary_svc_probability(sub_prob, param, weighted_C[i], weighted_C[j], probAB);
                  probA[p] = probAB[0];
                  probB[p] = probAB[1];
               }
               
               f[p] = svm_train_one(sub_prob, param, weighted_C[i], weighted_C[j]);
               for (k = 0; k < ci; k++) {
                  if (!nonzero[si + k] && Math.abs(f[p].alpha[k]) > 0) {
                     nonzero[si + k] = true;
                  }
               }
               for (k = 0; k < cj; k++) {
                  if (!nonzero[sj + k] && Math.abs(f[p].alpha[ci + k]) > 0) {
                     nonzero[sj + k] = true;
                  }
               }
               ++p;
            }
         }
         
         // build output
         
         model.nr_class = nr_class;
         
         model.label = new int[nr_class];
         for (i = 0; i < nr_class; i++) {
            model.label[i] = label[i];
         }
         
         model.rho = new double[nr_class * (nr_class - 1) / 2];
         for (i = 0; i < nr_class * (nr_class - 1) / 2; i++) {
            model.rho[i] = f[i].rho;
         }
         
         if (param.probability == 1)
         {
            model.probA = new double[nr_class * (nr_class - 1) / 2];
            model.probB = new double[nr_class * (nr_class - 1) / 2];
            for (i = 0; i < nr_class * (nr_class - 1) / 2; i++)
            {
               model.probA[i] = probA[i];
               model.probB[i] = probB[i];
            }
         }
         else
         {
            model.probA = null;
            model.probB = null;
         }
         
         int nnz = 0;
         final int[] nz_count = new int[nr_class];
         model.nSV = new int[nr_class];
         for (i = 0; i < nr_class; i++)
         {
            int nSV = 0;
            for (int j = 0; j < count[i]; j++) {
               if (nonzero[start[i] + j])
               {
                  ++nSV;
                  ++nnz;
               }
            }
            model.nSV[i] = nSV;
            nz_count[i] = nSV;
         }
         
         svm.info("Total nSV = " + nnz + "\n");
         
         model.l = nnz;
         model.SV = new svm_node[nnz][];
         p = 0;
         for (i = 0; i < l; i++) {
            if (nonzero[i]) {
               model.SV[p++] = x[i];
            }
         }
         
         final int[] nz_start = new int[nr_class];
         nz_start[0] = 0;
         for (i = 1; i < nr_class; i++) {
            nz_start[i] = nz_start[i - 1] + nz_count[i - 1];
         }
         
         model.sv_coef = new double[nr_class - 1][];
         for (i = 0; i < nr_class - 1; i++) {
            model.sv_coef[i] = new double[nnz];
         }
         
         p = 0;
         for (i = 0; i < nr_class; i++) {
            for (int j = i + 1; j < nr_class; j++)
            {
               // classifier (i,j): coefficients with
               // i are in sv_coef[j-1][nz_start[i]...],
               // j are in sv_coef[i][nz_start[j]...]
               
               final int si = start[i];
               final int sj = start[j];
               final int ci = count[i];
               final int cj = count[j];
               
               int q = nz_start[i];
               int k;
               for (k = 0; k < ci; k++) {
                  if (nonzero[si + k]) {
                     model.sv_coef[j - 1][q++] = f[p].alpha[k];
                  }
               }
               q = nz_start[j];
               for (k = 0; k < cj; k++) {
                  if (nonzero[sj + k]) {
                     model.sv_coef[i][q++] = f[p].alpha[ci + k];
                  }
               }
               ++p;
            }
         }
      }
      return model;
   }
   
   // Stratified cross validation
   public static void svm_cross_validation(final svm_problem prob, final svm_parameter param, final int nr_fold, final double[] target)
   {
      int i;
      final int[] fold_start = new int[nr_fold + 1];
      final int l = prob.l;
      final int[] perm = new int[l];
      
      // stratified cv may not give leave-one-out rate
      // Each class to l folds -> some folds may have zero elements
      if ((param.svm_type == svm_parameter.C_SVC ||
            param.svm_type == svm_parameter.NU_SVC) && nr_fold < l)
      {
         final int[] tmp_nr_class = new int[1];
         final int[][] tmp_label = new int[1][];
         final int[][] tmp_start = new int[1][];
         final int[][] tmp_count = new int[1][];
         
         svm_group_classes(prob, tmp_nr_class, tmp_label, tmp_start, tmp_count, perm);
         
         final int nr_class = tmp_nr_class[0];
         final int[] start = tmp_start[0];
         final int[] count = tmp_count[0];
         
         // random shuffle and then data grouped by fold using the array perm
         final int[] fold_count = new int[nr_fold];
         int c;
         final int[] index = new int[l];
         for (i = 0; i < l; i++) {
            index[i] = perm[i];
         }
         for (c = 0; c < nr_class; c++) {
            for (i = 0; i < count[c]; i++)
            {
               final int j = i + rand.nextInt(count[c] - i);
               do {
                  final int _ = index[start[c] + j];
                  index[start[c] + j] = index[start[c] + i];
                  index[start[c] + i] = _;
               } while (false);
            }
         }
         for (i = 0; i < nr_fold; i++)
         {
            fold_count[i] = 0;
            for (c = 0; c < nr_class; c++) {
               fold_count[i] += (i + 1) * count[c] / nr_fold - i * count[c] / nr_fold;
            }
         }
         fold_start[0] = 0;
         for (i = 1; i <= nr_fold; i++) {
            fold_start[i] = fold_start[i - 1] + fold_count[i - 1];
         }
         for (c = 0; c < nr_class; c++) {
            for (i = 0; i < nr_fold; i++)
            {
               final int begin = start[c] + i * count[c] / nr_fold;
               final int end = start[c] + (i + 1) * count[c] / nr_fold;
               for (int j = begin; j < end; j++)
               {
                  perm[fold_start[i]] = index[j];
                  fold_start[i]++;
               }
            }
         }
         fold_start[0] = 0;
         for (i = 1; i <= nr_fold; i++) {
            fold_start[i] = fold_start[i - 1] + fold_count[i - 1];
         }
      }
      else
      {
         for (i = 0; i < l; i++) {
            perm[i] = i;
         }
         for (i = 0; i < l; i++)
         {
            final int j = i + rand.nextInt(l - i);
            do {
               final int _ = perm[i];
               perm[i] = perm[j];
               perm[j] = _;
            } while (false);
         }
         for (i = 0; i <= nr_fold; i++) {
            fold_start[i] = i * l / nr_fold;
         }
      }
      
      for (i = 0; i < nr_fold; i++)
      {
         final int begin = fold_start[i];
         final int end = fold_start[i + 1];
         int j, k;
         final svm_problem subprob = new svm_problem();
         
         subprob.l = l - (end - begin);
         subprob.x = new svm_node[subprob.l][];
         subprob.y = new double[subprob.l];
         
         k = 0;
         for (j = 0; j < begin; j++)
         {
            subprob.x[k] = prob.x[perm[j]];
            subprob.y[k] = prob.y[perm[j]];
            ++k;
         }
         for (j = end; j < l; j++)
         {
            subprob.x[k] = prob.x[perm[j]];
            subprob.y[k] = prob.y[perm[j]];
            ++k;
         }
         final svm_model submodel = svm_train(subprob, param);
         if (param.probability == 1 &&
               (param.svm_type == svm_parameter.C_SVC ||
               param.svm_type == svm_parameter.NU_SVC))
         {
            final double[] prob_estimates = new double[svm_get_nr_class(submodel)];
            for (j = begin; j < end; j++) {
               target[perm[j]] = svm_predict_probability(submodel, prob.x[perm[j]], prob_estimates);
            }
         }
         else {
            for (j = begin; j < end; j++) {
               target[perm[j]] = svm_predict(submodel, prob.x[perm[j]]);
            }
         }
      }
   }
   
   public static int svm_get_svm_type(final svm_model model)
   {
      return model.param.svm_type;
   }
   
   public static int svm_get_nr_class(final svm_model model)
   {
      return model.nr_class;
   }
   
   public static void svm_get_labels(final svm_model model, final int[] label)
   {
      if (model.label != null) {
         for (int i = 0; i < model.nr_class; i++) {
            label[i] = model.label[i];
         }
      }
   }
   
   public static double svm_get_svr_probability(final svm_model model)
   {
      if ((model.param.svm_type == svm_parameter.EPSILON_SVR || model.param.svm_type == svm_parameter.NU_SVR) &&
            model.probA != null) {
         return model.probA[0];
      }
      else
      {
         System.err.print("Model doesn't contain information for SVR probability inference\n");
         return 0;
      }
   }
   
   public static double svm_predict_values(final svm_model model, final svm_node[] x, final double[] dec_values)
   {
      int i;
      if (model.param.svm_type == svm_parameter.ONE_CLASS ||
            model.param.svm_type == svm_parameter.EPSILON_SVR ||
            model.param.svm_type == svm_parameter.NU_SVR)
      {
         final double[] sv_coef = model.sv_coef[0];
         double sum = 0;
         for (i = 0; i < model.l; i++) {
            sum += sv_coef[i] * Kernel.k_function(x, model.SV[i], model.param);
         }
         sum -= model.rho[0];
         dec_values[0] = sum;
         
         if (model.param.svm_type == svm_parameter.ONE_CLASS) {
            return sum > 0 ? 1 : -1;
         }
         else {
            return sum;
         }
      }
      else
      {
         final int nr_class = model.nr_class;
         final int l = model.l;
         
         final double[] kvalue = new double[l];
         for (i = 0; i < l; i++) {
            kvalue[i] = Kernel.k_function(x, model.SV[i], model.param);
         }
         
         final int[] start = new int[nr_class];
         start[0] = 0;
         for (i = 1; i < nr_class; i++) {
            start[i] = start[i - 1] + model.nSV[i - 1];
         }
         
         final int[] vote = new int[nr_class];
         for (i = 0; i < nr_class; i++) {
            vote[i] = 0;
         }
         
         int p = 0;
         for (i = 0; i < nr_class; i++) {
            for (int j = i + 1; j < nr_class; j++)
            {
               double sum = 0;
               final int si = start[i];
               final int sj = start[j];
               final int ci = model.nSV[i];
               final int cj = model.nSV[j];
               
               int k;
               final double[] coef1 = model.sv_coef[j - 1];
               final double[] coef2 = model.sv_coef[i];
               for (k = 0; k < ci; k++) {
                  sum += coef1[si + k] * kvalue[si + k];
               }
               for (k = 0; k < cj; k++) {
                  sum += coef2[sj + k] * kvalue[sj + k];
               }
               sum -= model.rho[p];
               dec_values[p] = sum;
               
               if (dec_values[p] > 0) {
                  ++vote[i];
               }
               else {
                  ++vote[j];
               }
               p++;
            }
         }
         
         int vote_max_idx = 0;
         for (i = 1; i < nr_class; i++) {
            if (vote[i] > vote[vote_max_idx]) {
               vote_max_idx = i;
            }
         }
         
         return model.label[vote_max_idx];
      }
   }
   
   public static double svm_predict(final svm_model model, final svm_node[] x)
   {
      final int nr_class = model.nr_class;
      double[] dec_values;
      if (model.param.svm_type == svm_parameter.ONE_CLASS ||
            model.param.svm_type == svm_parameter.EPSILON_SVR ||
            model.param.svm_type == svm_parameter.NU_SVR) {
         dec_values = new double[1];
      }
      else {
         dec_values = new double[nr_class * (nr_class - 1) / 2];
      }
      final double pred_result = svm_predict_values(model, x, dec_values);
      return pred_result;
   }
   
   public static double svm_predict_probability(final svm_model model, final svm_node[] x, final double[] prob_estimates)
   {
      if ((model.param.svm_type == svm_parameter.C_SVC || model.param.svm_type == svm_parameter.NU_SVC) &&
            model.probA != null && model.probB != null)
      {
         int i;
         final int nr_class = model.nr_class;
         final double[] dec_values = new double[nr_class * (nr_class - 1) / 2];
         svm_predict_values(model, x, dec_values);
         
         final double min_prob = 1e-7;
         final double[][] pairwise_prob = new double[nr_class][nr_class];
         
         int k = 0;
         for (i = 0; i < nr_class; i++) {
            for (int j = i + 1; j < nr_class; j++)
            {
               pairwise_prob[i][j] = Math.min(Math.max(sigmoid_predict(dec_values[k], model.probA[k], model.probB[k]), min_prob), 1 - min_prob);
               pairwise_prob[j][i] = 1 - pairwise_prob[i][j];
               k++;
            }
         }
         multiclass_probability(nr_class, pairwise_prob, prob_estimates);
         
         int prob_max_idx = 0;
         for (i = 1; i < nr_class; i++) {
            if (prob_estimates[i] > prob_estimates[prob_max_idx]) {
               prob_max_idx = i;
            }
         }
         return model.label[prob_max_idx];
      }
      else {
         return svm_predict(model, x);
      }
   }
   
   static final String svm_type_table[] =
   {
         "c_svc", "nu_svc", "one_class", "epsilon_svr", "nu_svr",
   };
   
   static final String kernel_type_table[] =
   {
         "linear", "polynomial", "rbf", "sigmoid", "precomputed"
   };
   
   public static void svm_save_model(final String model_file_name, final svm_model model) throws IOException
   {
      final DataOutputStream fp = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(model_file_name)));
      
      final svm_parameter param = model.param;
      
      fp.writeBytes("svm_type " + svm_type_table[param.svm_type] + "\n");
      fp.writeBytes("kernel_type " + kernel_type_table[param.kernel_type] + "\n");
      
      if (param.kernel_type == svm_parameter.POLY) {
         fp.writeBytes("degree " + param.degree + "\n");
      }
      
      if (param.kernel_type == svm_parameter.POLY ||
            param.kernel_type == svm_parameter.RBF ||
            param.kernel_type == svm_parameter.SIGMOID) {
         fp.writeBytes("gamma " + param.gamma + "\n");
      }
      
      if (param.kernel_type == svm_parameter.POLY ||
            param.kernel_type == svm_parameter.SIGMOID) {
         fp.writeBytes("coef0 " + param.coef0 + "\n");
      }
      
      final int nr_class = model.nr_class;
      final int l = model.l;
      fp.writeBytes("nr_class " + nr_class + "\n");
      fp.writeBytes("total_sv " + l + "\n");
      
      {
         fp.writeBytes("rho");
         for (int i = 0; i < nr_class * (nr_class - 1) / 2; i++) {
            fp.writeBytes(" " + model.rho[i]);
         }
         fp.writeBytes("\n");
      }
      
      if (model.label != null)
      {
         fp.writeBytes("label");
         for (int i = 0; i < nr_class; i++) {
            fp.writeBytes(" " + model.label[i]);
         }
         fp.writeBytes("\n");
      }
      
      if (model.probA != null) // regression has probA only
      {
         fp.writeBytes("probA");
         for (int i = 0; i < nr_class * (nr_class - 1) / 2; i++) {
            fp.writeBytes(" " + model.probA[i]);
         }
         fp.writeBytes("\n");
      }
      if (model.probB != null)
      {
         fp.writeBytes("probB");
         for (int i = 0; i < nr_class * (nr_class - 1) / 2; i++) {
            fp.writeBytes(" " + model.probB[i]);
         }
         fp.writeBytes("\n");
      }
      
      if (model.nSV != null)
      {
         fp.writeBytes("nr_sv");
         for (int i = 0; i < nr_class; i++) {
            fp.writeBytes(" " + model.nSV[i]);
         }
         fp.writeBytes("\n");
      }
      
      fp.writeBytes("SV\n");
      final double[][] sv_coef = model.sv_coef;
      final svm_node[][] SV = model.SV;
      
      for (int i = 0; i < l; i++)
      {
         for (int j = 0; j < nr_class - 1; j++) {
            fp.writeBytes(sv_coef[j][i] + " ");
         }
         
         final svm_node[] p = SV[i];
         if (param.kernel_type == svm_parameter.PRECOMPUTED) {
            fp.writeBytes("0:" + (int) p[0].value);
         }
         else {
            for (final svm_node element : p) {
               fp.writeBytes(element.index + ":" + element.value + " ");
            }
         }
         fp.writeBytes("\n");
      }
      
      fp.close();
   }
   
   private static double atof(final String s)
   {
      return Double.valueOf(s).doubleValue();
   }
   
   private static int atoi(final String s)
   {
      return Integer.parseInt(s);
   }
   
   public static svm_model svm_load_model(final String model_file_name) throws IOException
   {
      return svm_load_model(new BufferedReader(new FileReader(model_file_name)));
   }
   
   public static svm_model svm_load_model(final BufferedReader fp) throws IOException
   {
      // read parameters
      
      final svm_model model = new svm_model();
      final svm_parameter param = new svm_parameter();
      model.param = param;
      model.rho = null;
      model.probA = null;
      model.probB = null;
      model.label = null;
      model.nSV = null;
      
      while (true)
      {
         final String cmd = fp.readLine();
         final String arg = cmd.substring(cmd.indexOf(' ') + 1);
         
         if (cmd.startsWith("svm_type"))
         {
            int i;
            for (i = 0; i < svm_type_table.length; i++)
            {
               if (arg.indexOf(svm_type_table[i]) != -1)
               {
                  param.svm_type = i;
                  break;
               }
            }
            if (i == svm_type_table.length)
            {
               System.err.print("unknown svm type.\n");
               return null;
            }
         }
         else if (cmd.startsWith("kernel_type"))
         {
            int i;
            for (i = 0; i < kernel_type_table.length; i++)
            {
               if (arg.indexOf(kernel_type_table[i]) != -1)
               {
                  param.kernel_type = i;
                  break;
               }
            }
            if (i == kernel_type_table.length)
            {
               System.err.print("unknown kernel function.\n");
               return null;
            }
         }
         else if (cmd.startsWith("degree")) {
            param.degree = atoi(arg);
         }
         else if (cmd.startsWith("gamma")) {
            param.gamma = atof(arg);
         }
         else if (cmd.startsWith("coef0")) {
            param.coef0 = atof(arg);
         }
         else if (cmd.startsWith("nr_class")) {
            model.nr_class = atoi(arg);
         }
         else if (cmd.startsWith("total_sv")) {
            model.l = atoi(arg);
         }
         else if (cmd.startsWith("rho"))
         {
            final int n = model.nr_class * (model.nr_class - 1) / 2;
            model.rho = new double[n];
            final StringTokenizer st = new StringTokenizer(arg);
            for (int i = 0; i < n; i++) {
               model.rho[i] = atof(st.nextToken());
            }
         }
         else if (cmd.startsWith("label"))
         {
            final int n = model.nr_class;
            model.label = new int[n];
            final StringTokenizer st = new StringTokenizer(arg);
            for (int i = 0; i < n; i++) {
               model.label[i] = atoi(st.nextToken());
            }
         }
         else if (cmd.startsWith("probA"))
         {
            final int n = model.nr_class * (model.nr_class - 1) / 2;
            model.probA = new double[n];
            final StringTokenizer st = new StringTokenizer(arg);
            for (int i = 0; i < n; i++) {
               model.probA[i] = atof(st.nextToken());
            }
         }
         else if (cmd.startsWith("probB"))
         {
            final int n = model.nr_class * (model.nr_class - 1) / 2;
            model.probB = new double[n];
            final StringTokenizer st = new StringTokenizer(arg);
            for (int i = 0; i < n; i++) {
               model.probB[i] = atof(st.nextToken());
            }
         }
         else if (cmd.startsWith("nr_sv"))
         {
            final int n = model.nr_class;
            model.nSV = new int[n];
            final StringTokenizer st = new StringTokenizer(arg);
            for (int i = 0; i < n; i++) {
               model.nSV[i] = atoi(st.nextToken());
            }
         }
         else if (cmd.startsWith("SV"))
         {
            break;
         }
         else
         {
            System.err.print("unknown text in model file: [" + cmd + "]\n");
            return null;
         }
      }
      
      // read sv_coef and SV
      
      final int m = model.nr_class - 1;
      final int l = model.l;
      model.sv_coef = new double[m][l];
      model.SV = new svm_node[l][];
      
      for (int i = 0; i < l; i++)
      {
         final String line = fp.readLine();
         final StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
         
         for (int k = 0; k < m; k++) {
            model.sv_coef[k][i] = atof(st.nextToken());
         }
         final int n = st.countTokens() / 2;
         model.SV[i] = new svm_node[n];
         for (int j = 0; j < n; j++)
         {
            model.SV[i][j] = new svm_node();
            model.SV[i][j].index = atoi(st.nextToken());
            model.SV[i][j].value = atof(st.nextToken());
         }
      }
      
      fp.close();
      return model;
   }
   
   public static String svm_check_parameter(final svm_problem prob, final svm_parameter param)
   {
      // svm_type
      
      final int svm_type = param.svm_type;
      if (svm_type != svm_parameter.C_SVC &&
            svm_type != svm_parameter.NU_SVC &&
            svm_type != svm_parameter.ONE_CLASS &&
            svm_type != svm_parameter.EPSILON_SVR &&
            svm_type != svm_parameter.NU_SVR) {
         return "unknown svm type";
      }
      
      // kernel_type, degree
      
      final int kernel_type = param.kernel_type;
      if (kernel_type != svm_parameter.LINEAR &&
            kernel_type != svm_parameter.POLY &&
            kernel_type != svm_parameter.RBF &&
            kernel_type != svm_parameter.SIGMOID &&
            kernel_type != svm_parameter.PRECOMPUTED) {
         return "unknown kernel type";
      }
      
      if (param.gamma < 0) {
         return "gamma < 0";
      }
      
      if (param.degree < 0) {
         return "degree of polynomial kernel < 0";
      }
      
      // cache_size,eps,C,nu,p,shrinking
      
      if (param.cache_size <= 0) {
         return "cache_size <= 0";
      }
      
      if (param.eps <= 0) {
         return "eps <= 0";
      }
      
      if (svm_type == svm_parameter.C_SVC ||
            svm_type == svm_parameter.EPSILON_SVR ||
            svm_type == svm_parameter.NU_SVR) {
         if (param.C <= 0) {
            return "C <= 0";
         }
      }
      
      if (svm_type == svm_parameter.NU_SVC ||
            svm_type == svm_parameter.ONE_CLASS ||
            svm_type == svm_parameter.NU_SVR) {
         if (param.nu <= 0 || param.nu > 1) {
            return "nu <= 0 or nu > 1";
         }
      }
      
      if (svm_type == svm_parameter.EPSILON_SVR) {
         if (param.p < 0) {
            return "p < 0";
         }
      }
      
      if (param.shrinking != 0 &&
            param.shrinking != 1) {
         return "shrinking != 0 and shrinking != 1";
      }
      
      if (param.probability != 0 &&
            param.probability != 1) {
         return "probability != 0 and probability != 1";
      }
      
      if (param.probability == 1 &&
            svm_type == svm_parameter.ONE_CLASS) {
         return "one-class SVM probability output not supported yet";
      }
      
      // check whether nu-svc is feasible
      
      if (svm_type == svm_parameter.NU_SVC)
      {
         final int l = prob.l;
         int max_nr_class = 16;
         int nr_class = 0;
         int[] label = new int[max_nr_class];
         int[] count = new int[max_nr_class];
         
         int i;
         for (i = 0; i < l; i++)
         {
            final int this_label = (int) prob.y[i];
            int j;
            for (j = 0; j < nr_class; j++) {
               if (this_label == label[j])
               {
                  ++count[j];
                  break;
               }
            }
            
            if (j == nr_class)
            {
               if (nr_class == max_nr_class)
               {
                  max_nr_class *= 2;
                  int[] new_data = new int[max_nr_class];
                  System.arraycopy(label, 0, new_data, 0, label.length);
                  label = new_data;
                  
                  new_data = new int[max_nr_class];
                  System.arraycopy(count, 0, new_data, 0, count.length);
                  count = new_data;
               }
               label[nr_class] = this_label;
               count[nr_class] = 1;
               ++nr_class;
            }
         }
         
         for (i = 0; i < nr_class; i++)
         {
            final int n1 = count[i];
            for (int j = i + 1; j < nr_class; j++)
            {
               final int n2 = count[j];
               if (param.nu * (n1 + n2) / 2 > Math.min(n1, n2)) {
                  return "specified nu is infeasible";
               }
            }
         }
      }
      
      return null;
   }
   
   public static int svm_check_probability_model(final svm_model model)
   {
      if ((model.param.svm_type == svm_parameter.C_SVC || model.param.svm_type == svm_parameter.NU_SVC) &&
            model.probA != null && model.probB != null ||
            (model.param.svm_type == svm_parameter.EPSILON_SVR || model.param.svm_type == svm_parameter.NU_SVR) &&
            model.probA != null) {
         return 1;
      }
      else {
         return 0;
      }
   }
   
   public static void svm_set_print_string_function(final svm_print_interface print_func)
   {
      if (print_func == null) {
         svm_print_string = svm_print_stdout;
      }
      else {
         svm_print_string = print_func;
      }
   }
}
